#pragma once

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <unordered_map>
#include <muduo/base/Logging.h>

#include <muduo/net/EventLoop.h>
#include <muduo/net/TcpServer.h>
#include "../router/Router.h"
#include "HttpContext.h"
#include "HttpRequest.h"
#include "HttpResponse.h"
#include "../session/SessionManager.hpp"
#include "../middleWare/MiddlewareChain.hpp"
namespace http
{

    class HttpServer : muduo::noncopyable
    {
    private:
        void initialize();

    public:
        using HttpCallback = std::function<void(const http::HttpRequest &, http::HttpResponse &)>;

        // 修改构造函数，添加参数
        HttpServer(muduo::net::EventLoop *loop, const muduo::net::InetAddress &listenAddr, const std::string &name);

        // 添加启动服务器的方法
        void start();
        void SetHttpCallback(const HttpCallback &cb);
        void OnConnection(const muduo::net::TcpConnectionPtr &conn);                                                     // 连接建立回调
        void OnMessage(const muduo::net::TcpConnectionPtr &conn, muduo::net::Buffer *buf, muduo::Timestamp receiveTime); // 消息到达回调
        void OnRequest(const muduo::net::TcpConnectionPtr &conn, const HttpRequest &req);                                // 请求到达回调
        void handleRequest(const HttpRequest &req, HttpResponse &resp);                                                  // 处理请求
        // 业务层提供业务回调接口
        // 业务层可以通过这些提供的接口，注册URL与业务逻辑的映射关系
        // 业务层可以注册GET、POST、正则表达式路由处理函数（回调函数）和对象式路由处理函数
        // 前者适用回调函数执行简单的场景，后者适用回调函数执行复杂的场景
        // 总的来说他们都是注册请求URI对应执行的回调函数
        // 注册get静态路由处理函数（回调函数）
        void Get(const std::string &path, const HttpCallback &cb)
        {
            _router.registerCallback(path, HttpRequest::Get, cb);
        }
        // 注册get静态路由处理函数（对象式）
        void Get(const std::string &path, router::Router::HandlerPtr handler)
        {
            _router.registerHandler(path, HttpRequest::Get, handler);
        }
        // 注册post静态路由处理函数（回调函数）
        void Post(const std::string &path, const HttpCallback &cb)
        {
            _router.registerCallback(path, HttpRequest::Post, cb);
        }
        // 注册post静态路由处理函数（对象式）
        void Post(const std::string &path, router::Router::HandlerPtr handler)
        {
            _router.registerHandler(path, HttpRequest::Post, handler);
        }
        // 注册正则表达式路由处理函数（对象式）
        void addRoute(HttpRequest::Method method, const std::string &path, router::Router::HandlerPtr handler)
        {
            _router.addRegexHandler(path, method, handler);
        }
        // 注册正则表达式路由处理函数（回调函数）
        void addRoute(HttpRequest::Method method, const std::string &path, const router::Router::HandlerCallback &cb)
        {
            _router.addRegexCallback(path, method, cb);
        }
        // 注册会话管理器
        void setSessionManager(std::unique_ptr<session::SessionManager> sessionManager)
        {
            _sessionManager = std::move(sessionManager); // 移动语义 移动构造函数
        }
        // 获取会话管理器
        session::SessionManager *getSessionManager() const
        {
            return _sessionManager.get();
        }
        // 注册中间件
        void addMiddleware(std::shared_ptr<middleWare::Middleware> middleware)
        {
            _middlewareChain.addMiddleware(middleware);
        }

    private:
        muduo::net::EventLoop *_mainLoop;                         // 事件循环
        muduo::net::InetAddress _listenAddr;                      // 监听地址
        muduo::net::TcpServer _server;                            // 服务器
        router::Router _router;                                   // 路由器
        HttpCallback _httpCallback;                               // HTTP回调函数
        std::unique_ptr<session::SessionManager> _sessionManager; // 会话管理器
        middleWare::MiddlewareChain _middlewareChain;             // 中间件管理器
    };
} // namespace http
